# -*- coding: utf-8 -*-
from gi.repository import GObject


class ArrayType:
    """The type of array in a #GITypeInfo."""
    C = 0
    ARRAY = 1
    PTR_ARRAY = 2
    BYTE_ARRAY = 3


class Direction:
    """The direction of a #GIArgInfo."""
    IN = 0
    OUT = 1
    INOUT = 2


class FieldInfoFlags:
    """Flags for a #GIFieldInfo."""
    READABLE = 1
    WRITABLE = 2


class FunctionInfoFlags:
    """Flags for a #GIFunctionInfo struct."""
    IS_METHOD = 1
    IS_CONSTRUCTOR = 2
    IS_GETTER = 4
    IS_SETTER = 8
    WRAPS_VFUNC = 16
    THROWS = 32


class InfoType:
    """The type of a GIBaseInfo struct."""
    INVALID = 0
    FUNCTION = 1
    CALLBACK = 2
    STRUCT = 3
    BOXED = 4
    ENUM = 5
    FLAGS = 6
    OBJECT = 7
    INTERFACE = 8
    CONSTANT = 9
    INVALID_0 = 10
    UNION = 11
    VALUE = 12
    SIGNAL = 13
    VFUNC = 14
    PROPERTY = 15
    FIELD = 16
    ARG = 17
    TYPE = 18
    UNRESOLVED = 19


class RepositoryError:
    """An error code used with #G_IREPOSITORY_ERROR in a #GError returned
from a #GIRepository routine."""
    TYPELIB_NOT_FOUND = 0
    NAMESPACE_MISMATCH = 1
    NAMESPACE_VERSION_CONFLICT = 2
    LIBRARY_NOT_FOUND = 3


class RepositoryLoadFlags:
    """Flags that control how a typelib is loaded."""
    IREPOSITORY_LOAD_FLAG_LAZY = 1


class ScopeType:
    """Scope type of a #GIArgInfo representing callback, determines how the
callback is invoked and is used to decided when the invoke structs
can be freed."""
    INVALID = 0
    CALL = 1
    ASYNC = 2
    NOTIFIED = 3


class Transfer:
    """The transfer is the exchange of data between two parts, from the callee to
the caller. The callee is either a function/method/signal or an
object/interface where a property is defined. The caller is the side
accessing a property or calling a function.
#GITransfer specifies who's responsible for freeing the resources after the
ownership transfer is complete. In case of a containing type such as a list,
an array or a hash table the container itself is specified differently from
the items within the container itself. Each container is freed differently,
check the documentation for the types themselves for information on how to
free them."""
    NOTHING = 0
    CONTAINER = 1
    EVERYTHING = 2


class TypeTag:
    """The type tag of a #GITypeInfo."""
    VOID = 0
    BOOLEAN = 1
    INT8 = 2
    UINT8 = 3
    INT16 = 4
    UINT16 = 5
    INT32 = 6
    UINT32 = 7
    INT64 = 8
    UINT64 = 9
    FLOAT = 10
    DOUBLE = 11
    GTYPE = 12
    UTF8 = 13
    FILENAME = 14
    ARRAY = 15
    INTERFACE = 16
    GLIST = 17
    GSLIST = 18
    GHASH = 19
    ERROR = 20
    UNICHAR = 21


class VFuncInfoFlags:
    """Flags of a #GIVFuncInfo struct."""
    MUST_CHAIN_UP = 1
    MUST_OVERRIDE = 2
    MUST_NOT_OVERRIDE = 4
    THROWS = 8

def arg_info_get_closure(info=None):
    """    Obtain the index of the user data argument. This is only valid
    for arguments which are callbacks.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: index of the user data argument or -1 if there is none
    @rtype: int
    """
    return object

def arg_info_get_destroy(info=None):
    """    Obtains the index of the #GDestroyNotify argument. This is only valid
    for arguments which are callbacks.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: index of the #GDestroyNotify argument or -1 if there is none
    @rtype: int
    """
    return object

def arg_info_get_direction(info=None):
    """    Obtain the direction of the argument. Check #GIDirection for possible
    direction values.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: the direction
    @rtype: Direction
    """
    return object

def arg_info_get_ownership_transfer(info=None):
    """    Obtain the ownership transfer for this argument.
    #GITransfer contains a list of possible values.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: the transfer
    @rtype: Transfer
    """
    return object

def arg_info_get_scope(info=None):
    """    Obtain the scope type for this argument. The scope type explains
    how a callback is going to be invoked, most importantly when
    the resources required to invoke it can be freed.
    #GIScopeType contains a list of possible values.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: the scope type
    @rtype: ScopeType
    """
    return object

def arg_info_get_type(info=None):
    """    Obtain the type information for @info.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: the #GITypeInfo holding the type
   information for @info, free it with g_base_info_unref()
   when done.
    @rtype: TypeInfo
    """
    return object

def arg_info_is_caller_allocates(info=None):
    """    Obtain if the argument is a pointer to a struct or object that will
    receive an output of a function.  The default assumption for
    %GI_DIRECTION_OUT arguments which have allocation is that the
    callee allocates; if this is %TRUE, then the caller must allocate.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: %TRUE if caller is required to have allocated the argument
    @rtype: bool
    """
    return object

def arg_info_is_optional(info=None):
    """    Obtain if the argument is optional.  For 'out' arguments this means
    that you can pass %NULL in order to ignore the result.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: %TRUE if it is an optional argument
    @rtype: bool
    """
    return object

def arg_info_is_return_value(info=None):
    """    Obtain if the argument is a return value. It can either be a
    parameter or a return value.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: %TRUE if it is a return value
    @rtype: bool
    """
    return object

def arg_info_is_skip(info=None):
    """    Obtain if an argument is only useful in C.
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: %TRUE if argument is only useful in C.
    @rtype: bool
    """
    return object

def arg_info_load_type(info=None, type=None):
    """    Obtain information about a the type of given argument @info; this
    function is a variant of g_arg_info_get_type() designed for stack
    allocation.
    
    The initialized @type must not be referenced after @info is deallocated.
    @param info: a #GIArgInfo
    @param type: Initialized with information about type of @info
    @type info: ArgInfo
    @type type: TypeInfo
    @returns: 
    @rtype: None
    """
    return object

def arg_info_may_be_null(info=None):
    """    Obtain if the type of the argument includes the possibility of %NULL.
    For 'in' values this means that %NULL is a valid value.  For 'out'
    values, this means that %NULL may be returned.
    
    See also g_arg_info_is_optional().
    @param info: a #GIArgInfo
    @type info: ArgInfo
    @returns: %TRUE if the value may be %NULL
    @rtype: bool
    """
    return object

def callable_info_can_throw_gerror(info=None):
    """    TODO
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: %TRUE if this #GICallableInfo can throw a #GError
    @rtype: bool
    """
    return object

def callable_info_get_arg(info=None, n=None):
    """    Obtain information about a particular argument of this callable.
    @param info: a #GICallableInfo
    @param n: the argument index to fetch
    @type info: CallableInfo
    @type n: int
    @returns: the #GIArgInfo. Free it with g_base_info_unref() when done.
    @rtype: ArgInfo
    """
    return object

def callable_info_get_caller_owns(info=None):
    """    See whether the caller owns the return value of this callable.
    #GITransfer contains a list of possible transfer values.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: the transfer mode for the return value of the callable
    @rtype: Transfer
    """
    return object

def callable_info_get_instance_ownership_transfer(info=None):
    """    Obtains the ownership transfer for the instance argument.
    #GITransfer contains a list of possible transfer values.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: the transfer mode of the instance argument
    @rtype: Transfer
    """
    return object

def callable_info_get_n_args(info=None):
    """    Obtain the number of arguments (both IN and OUT) for this callable.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: The number of arguments this callable expects.
    @rtype: int
    """
    return object

def callable_info_get_return_attribute(info=None, name=None):
    """    Retrieve an arbitrary attribute associated with the return value.
    @param info: a #GICallableInfo
    @param name: a freeform string naming an attribute
    @type info: CallableInfo
    @type name: str
    @returns: The value of the attribute, or %NULL if no such attribute exists
    @rtype: str
    """
    return object

def callable_info_get_return_type(info=None):
    """    Obtain the return type of a callable item as a #GITypeInfo.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: the #GITypeInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: TypeInfo
    """
    return object

def callable_info_invoke(info=None, function=None, in_args=None, n_in_args=None, out_args=None, n_out_args=None, return_value=None, is_method=None, throws=None):
    """    TODO
    @param info: TODO
    @param function: TODO
    @param in_args: TODO
    @param n_in_args: TODO
    @param out_args: TODO
    @param n_out_args: TODO
    @param return_value: TODO
    @param is_method: TODO
    @param throws: TODO
    @type info: CallableInfo
    @type function: gpointer
    @type n_in_args: int
    @type n_out_args: int
    @type return_value: Argument
    @type is_method: bool
    @type throws: bool
    @returns: 
    @rtype: bool
    """
    return object

def callable_info_is_method(info=None):
    """    Determines if the callable info is a method. For #GIVFuncInfo<!-- -->s,
    #GICallbackInfo<!-- -->s, and #GISignalInfo<!-- -->s,
    this is always true. Otherwise, this looks at the %GI_FUNCTION_IS_METHOD
    flag on the #GIFunctionInfo.
    
    Concretely, this function returns whether g_callable_info_get_n_args()
    matches the number of arguments in the raw C method. For methods, there
    is one more C argument than is exposed by introspection: the "self"
    or "this" object.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: %TRUE if @info is a method, %FALSE otherwise
    @rtype: bool
    """
    return object

def callable_info_iterate_return_attributes(info=None, iterator=None, name=None, value=None):
    """    Iterate over all attributes associated with the return value.  The
    iterator structure is typically stack allocated, and must have its
    first member initialized to %NULL.
    
    Both the @name and @value should be treated as constants
    and must not be freed.
    
    See g_base_info_iterate_attributes() for an example of how to use a
    similar API.
    @param info: a #GICallableInfo
    @param iterator: a #GIAttributeIter structure, must be initialized; see below
    @param name: Returned name, must not be freed
    @param value: Returned name, must not be freed
    @type info: CallableInfo
    @type iterator: AttributeIter
    @type name: str
    @type value: str
    @returns: %TRUE if there are more attributes
    @rtype: bool
    """
    return object

def callable_info_load_arg(info=None, n=None, arg=None):
    """    Obtain information about a particular argument of this callable; this
    function is a variant of g_callable_info_get_arg() designed for stack
    allocation.
    
    The initialized @arg must not be referenced after @info is deallocated.
    @param info: a #GICallableInfo
    @param n: the argument index to fetch
    @param arg: Initialize with argument number @n
    @type info: CallableInfo
    @type n: int
    @type arg: ArgInfo
    @returns: 
    @rtype: None
    """
    return object

def callable_info_load_return_type(info=None, type=None):
    """    Obtain information about a return value of callable; this
    function is a variant of g_callable_info_get_return_type() designed for stack
    allocation.
    
    The initialized @type must not be referenced after @info is deallocated.
    @param info: a #GICallableInfo
    @param type: Initialized with return type of @info
    @type info: CallableInfo
    @type type: TypeInfo
    @returns: 
    @rtype: None
    """
    return object

def callable_info_may_return_null(info=None):
    """    See if a callable could return %NULL.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: %TRUE if callable could return %NULL
    @rtype: bool
    """
    return object

def callable_info_skip_return(info=None):
    """    See if a callable's return value is only useful in C.
    @param info: a #GICallableInfo
    @type info: CallableInfo
    @returns: %TRUE if return value is only useful in C.
    @rtype: bool
    """
    return object

def constant_info_free_value(info=None, value=None):
    """    Free the value returned from g_constant_info_get_value().
    @param info: a #GIConstantInfo
    @param value: the argument
    @type info: ConstantInfo
    @type value: Argument
    @returns: 
    @rtype: None
    """
    return object

def constant_info_get_type(info=None):
    """    Obtain the type of the constant as a #GITypeInfo.
    @param info: a #GIConstantInfo
    @type info: ConstantInfo
    @returns: the #GITypeInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: TypeInfo
    """
    return object

def constant_info_get_value(info=None, value=None):
    """    Obtain the value associated with the #GIConstantInfo and store it in the
    @value parameter. @argument needs to be allocated before passing it in.
    The size of the constant value stored in @argument will be returned.
    Free the value with g_constant_info_free_value().
    @param info: a #GIConstantInfo
    @param value: an argument
    @type info: ConstantInfo
    @type value: Argument
    @returns: size of the constant
    @rtype: int
    """
    return object

def enum_info_get_error_domain(info=None):
    """    Obtain the string form of the quark for the error domain associated with
    this enum, if any.
    @param info: a #GIEnumInfo
    @type info: EnumInfo
    @returns: the string form of the error domain associated with this enum, or %NULL.
    @rtype: str
    """
    return object

def enum_info_get_method(info=None, n=None):
    """    Obtain an enum type method at index @n.
    @param info: a #GIEnumInfo
    @param n: index of method to get
    @type info: EnumInfo
    @type n: int
    @returns: the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def enum_info_get_n_methods(info=None):
    """    Obtain the number of methods that this enum type has.
    @param info: a #GIEnumInfo
    @type info: EnumInfo
    @returns: number of methods
    @rtype: int
    """
    return object

def enum_info_get_n_values(info=None):
    """    Obtain the number of values this enumeration contains.
    @param info: a #GIEnumInfo
    @type info: EnumInfo
    @returns: the number of enumeration values
    @rtype: int
    """
    return object

def enum_info_get_storage_type(info=None):
    """    Obtain the tag of the type used for the enum in the C ABI. This will
    will be a signed or unsigned integral type.
    
    Note that in the current implementation the width of the type is
    computed correctly, but the signed or unsigned nature of the type
    may not match the sign of the type used by the C compiler.
    @param info: a #GIEnumInfo
    @type info: EnumInfo
    @returns: the storage type for the enumeration
    @rtype: TypeTag
    """
    return object

def enum_info_get_value(info=None, n=None):
    """    Obtain a value for this enumeration.
    @param info: a #GIEnumInfo
    @param n: index of value to fetch
    @type info: EnumInfo
    @type n: int
    @returns: the enumeration value or %NULL if type tag is wrong, free the struct with g_base_info_unref() when done.
    @rtype: ValueInfo
    """
    return object

def field_info_get_field(field_info=None, mem=None, value=None):
    """    Reads a field identified by a #GIFieldInfo from a C structure or
    union.  This only handles fields of simple C types. It will fail
    for a field of a composite type like a nested structure or union
    even if that is actually readable.
    @param field_info: a #GIFieldInfo
    @param mem: pointer to a block of memory representing a C structure or union
    @param value: a #GIArgument into which to store the value retrieved
    @type field_info: FieldInfo
    @type mem: gpointer
    @type value: Argument
    @returns: %TRUE if reading the field succeeded, otherwise %FALSE
    @rtype: bool
    """
    return object

def field_info_get_flags(info=None):
    """    Obtain the flags for this #GIFieldInfo. See #GIFieldInfoFlags for possible
    flag values.
    @param info: a #GIFieldInfo
    @type info: FieldInfo
    @returns: the flags
    @rtype: FieldInfoFlags
    """
    return object

def field_info_get_offset(info=None):
    """    Obtain the offset in bits of the field member, this is relative
    to the beginning of the struct or union.
    @param info: a #GIFieldInfo
    @type info: FieldInfo
    @returns: the field offset
    @rtype: int
    """
    return object

def field_info_get_size(info=None):
    """    Obtain the size in bits of the field member, this is how
    much space you need to allocate to store the field.
    @param info: a #GIFieldInfo
    @type info: FieldInfo
    @returns: the field size
    @rtype: int
    """
    return object

def field_info_get_type(info=None):
    """    Obtain the type of a field as a #GITypeInfo.
    @param info: a #GIFieldInfo
    @type info: FieldInfo
    @returns: the #GITypeInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: TypeInfo
    """
    return object

def field_info_set_field(field_info=None, mem=None, value=None):
    """    Writes a field identified by a #GIFieldInfo to a C structure or
    union.  This only handles fields of simple C types. It will fail
    for a field of a composite type like a nested structure or union
    even if that is actually writable. Note also that that it will refuse
    to write fields where memory management would by required. A field
    with a type such as 'char *' must be set with a setter function.
    @param field_info: a #GIFieldInfo
    @param mem: pointer to a block of memory representing a C structure or union
    @param value: a #GIArgument holding the value to store
    @type field_info: FieldInfo
    @type mem: gpointer
    @type value: Argument
    @returns: %TRUE if writing the field succeeded, otherwise %FALSE
    @rtype: bool
    """
    return object

def function_info_get_flags(info=None):
    """    Obtain the #GIFunctionInfoFlags for the @info.
    @param info: a #GIFunctionInfo
    @type info: FunctionInfo
    @returns: the flags
    @rtype: FunctionInfoFlags
    """
    return object

def function_info_get_property(info=None):
    """    Obtain the property associated with this #GIFunctionInfo.
    Only #GIFunctionInfo with the flag %GI_FUNCTION_IS_GETTER or
    %GI_FUNCTION_IS_SETTER have a property set. For other cases,
    %NULL will be returned.
    @param info: a #GIFunctionInfo
    @type info: FunctionInfo
    @returns: the property or %NULL if not set. Free it with g_base_info_unref() when done.
    @rtype: PropertyInfo
    """
    return object

def function_info_get_symbol(info=None):
    """    Obtain the symbol of the function. The symbol is the name of the
    exported function, suitable to be used as an argument to
    g_module_symbol().
    @param info: a #GIFunctionInfo
    @type info: FunctionInfo
    @returns: the symbol
    @rtype: str
    """
    return object

def function_info_get_vfunc(info=None):
    """    Obtain the virtual function associated with this #GIFunctionInfo.
    Only #GIFunctionInfo with the flag %GI_FUNCTION_WRAPS_VFUNC has
    a virtual function set. For other cases, %NULL will be returned.
    @param info: a #GIFunctionInfo
    @type info: FunctionInfo
    @returns: the virtual function or %NULL if not set. Free it by calling g_base_info_unref() when done.
    @rtype: VFuncInfo
    """
    return object

def function_info_invoke(info=None, in_args=None, n_in_args=None, out_args=None, n_out_args=None, return_value=None):
    """    Invokes the function described in @info with the given
    arguments. Note that inout parameters must appear in both
    argument lists. This function uses dlsym() to obtain a pointer
    to the function, so the library or shared object containing the
    described function must either be linked to the caller, or must
    have been g_module_symbol()<!-- -->ed before calling this function.
    @param info: a #GIFunctionInfo describing the function to invoke
    @param in_args: an array of #GIArgument<!-- -->s, one for each in    parameter of @info. If there are no in parameter, @in_args    can be %NULL
    @param n_in_args: the length of the @in_args array
    @param out_args: an array of #GIArgument<!-- -->s, one for each out    parameter of @info. If there are no out parameters, @out_args    may be %NULL
    @param n_out_args: the length of the @out_args array
    @param return_value: return location for the return value of the    function. If the function returns void, @return_value may be    %NULL
    @type info: FunctionInfo
    @type n_in_args: int
    @type n_out_args: int
    @type return_value: Argument
    @returns: %TRUE if the function has been invoked, %FALSE if an
   error occurred.
    @rtype: bool
    """
    return object

def info_new(type=None, container=None, typelib=None, offset=None):
    """    TODO
    @param type: TODO
    @param container: TODO
    @param typelib: TODO
    @param offset: TODO
    @type type: InfoType
    @type container: BaseInfo
    @type typelib: Typelib
    @type offset: guint32
    @returns: TODO
    @rtype: BaseInfo
    """
    return object

def info_type_to_string(type=None):
    """    Obtain a string representation of @type
    @param type: the info type
    @type type: InfoType
    @returns: the string
    @rtype: str
    """
    return object

def interface_info_find_method(info=None, name=None):
    """    Obtain a method of the interface type given a @name. %NULL will be
    returned if there's no method available with that name.
    @param info: a #GIInterfaceInfo
    @param name: name of method to obtain
    @type info: InterfaceInfo
    @type name: str
    @returns: the #GIFunctionInfo or %NULL if none found. Free the struct by calling g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def interface_info_find_signal(info=None, name=None):
    """    TODO
    @param info: a #GIInterfaceInfo
    @param name: Name of signal
    @type info: InterfaceInfo
    @type name: str
    @returns: Info for the signal with name @name in @info, or %NULL on failure.
    @rtype: SignalInfo
    """
    return object

def interface_info_find_vfunc(info=None, name=None):
    """    Locate a virtual function slot with name @name. See the documentation
    for g_object_info_find_vfunc() for more information on virtuals.
    @param info: a #GIInterfaceInfo
    @param name: The name of a virtual function to find.
    @type info: InterfaceInfo
    @type name: str
    @returns: the #GIVFuncInfo, or %NULL. Free it with g_base_info_unref() when done.
    @rtype: VFuncInfo
    """
    return object

def interface_info_get_constant(info=None, n=None):
    """    Obtain an interface type constant at index @n.
    @param info: a #GIInterfaceInfo
    @param n: index of constant to get
    @type info: InterfaceInfo
    @type n: int
    @returns: the #GIConstantInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: ConstantInfo
    """
    return object

def interface_info_get_iface_struct(info=None):
    """    Returns the layout C structure associated with this #GInterface.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: the #GIStructInfo or %NULL. Free it with g_base_info_unref() when done.
    @rtype: StructInfo
    """
    return object

def interface_info_get_method(info=None, n=None):
    """    Obtain an interface type method at index @n.
    @param info: a #GIInterfaceInfo
    @param n: index of method to get
    @type info: InterfaceInfo
    @type n: int
    @returns: the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def interface_info_get_n_constants(info=None):
    """    Obtain the number of constants that this interface type has.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: number of constants
    @rtype: int
    """
    return object

def interface_info_get_n_methods(info=None):
    """    Obtain the number of methods that this interface type has.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: number of methods
    @rtype: int
    """
    return object

def interface_info_get_n_prerequisites(info=None):
    """    Obtain the number of prerequisites for this interface type.
    A prerequisites is another interface that needs to be implemented for
    interface, similar to an base class for GObjects.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: number of prerequisites
    @rtype: int
    """
    return object

def interface_info_get_n_properties(info=None):
    """    Obtain the number of properties that this interface type has.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: number of properties
    @rtype: int
    """
    return object

def interface_info_get_n_signals(info=None):
    """    Obtain the number of signals that this interface type has.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: number of signals
    @rtype: int
    """
    return object

def interface_info_get_n_vfuncs(info=None):
    """    Obtain the number of virtual functions that this interface type has.
    @param info: a #GIInterfaceInfo
    @type info: InterfaceInfo
    @returns: number of virtual functions
    @rtype: int
    """
    return object

def interface_info_get_prerequisite(info=None, n=None):
    """    Obtain an interface type prerequisites index @n.
    @param info: a #GIInterfaceInfo
    @param n: index of prerequisites to get
    @type info: InterfaceInfo
    @type n: int
    @returns: the prerequisites as a #GIBaseInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: BaseInfo
    """
    return object

def interface_info_get_property(info=None, n=None):
    """    Obtain an interface type property at index @n.
    @param info: a #GIInterfaceInfo
    @param n: index of property to get
    @type info: InterfaceInfo
    @type n: int
    @returns: the #GIPropertyInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: PropertyInfo
    """
    return object

def interface_info_get_signal(info=None, n=None):
    """    Obtain an interface type signal at index @n.
    @param info: a #GIInterfaceInfo
    @param n: index of signal to get
    @type info: InterfaceInfo
    @type n: int
    @returns: the #GISignalInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: SignalInfo
    """
    return object

def interface_info_get_vfunc(info=None, n=None):
    """    Obtain an interface type virtual function at index @n.
    @param info: a #GIInterfaceInfo
    @param n: index of virtual function to get
    @type info: InterfaceInfo
    @type n: int
    @returns: the #GIVFuncInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: VFuncInfo
    """
    return object

def invoke_error_quark():
    """    TODO
    @returns: TODO
    @rtype: GLib.Quark
    """
    return object


class nvokeError:
    """An error occuring while invoking a function via
g_function_info_invoke()."""
    FAILED = 0
    SYMBOL_NOT_FOUND = 1
    ARGUMENT_MISMATCH = 2

def object_info_find_method(info=None, name=None):
    """    Obtain a method of the object type given a @name. %NULL will be
    returned if there's no method available with that name.
    @param info: a #GIObjectInfo
    @param name: name of method to obtain
    @type info: ObjectInfo
    @type name: str
    @returns: the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def object_info_find_method_using_interfaces(info=None, name=None, implementor=None):
    """    Obtain a method of the object given a @name, searching both the
    object @info and any interfaces it implements.  %NULL will be
    returned if there's no method available with that name.
    
    Note that this function does *not* search parent classes; you will have
    to chain up if that's desired.
    @param info: a #GIObjectInfo
    @param name: name of method to obtain
    @param implementor: The implementor of the interface
    @type info: ObjectInfo
    @type name: str
    @type implementor: ObjectInfo
    @returns: the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def object_info_find_signal(info=None, name=None):
    """    TODO
    @param info: a #GIObjectInfo
    @param name: Name of signal
    @type info: ObjectInfo
    @type name: str
    @returns: Info for the signal with name @name in @info, or %NULL on failure.
    @rtype: SignalInfo
    """
    return object

def object_info_find_vfunc(info=None, name=None):
    """    Locate a virtual function slot with name @name. Note that the namespace
    for virtuals is distinct from that of methods; there may or may not be
    a concrete method associated for a virtual. If there is one, it may
    be retrieved using g_vfunc_info_get_invoker(), otherwise %NULL will be
    returned.
    See the documentation for g_vfunc_info_get_invoker() for more
    information on invoking virtuals.
    @param info: a #GIObjectInfo
    @param name: The name of a virtual function to find.
    @type info: ObjectInfo
    @type name: str
    @returns: the #GIVFuncInfo, or %NULL. Free it with g_base_info_unref() when done.
    @rtype: VFuncInfo
    """
    return object

def object_info_find_vfunc_using_interfaces(info=None, name=None, implementor=None):
    """    Locate a virtual function slot with name @name, searching both the object
    @info and any interfaces it implements.  Note that the namespace for
    virtuals is distinct from that of methods; there may or may not be a
    concrete method associated for a virtual. If there is one, it may be
    retrieved using g_vfunc_info_get_invoker(), otherwise %NULL will be
    returned.
    
    Note that this function does *not* search parent classes; you will have
    to chain up if that's desired.
    @param info: a #GIObjectInfo
    @param name: name of method to obtain
    @param implementor: The implementor of the interface
    @type info: ObjectInfo
    @type name: str
    @type implementor: ObjectInfo
    @returns: the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: VFuncInfo
    """
    return object

def object_info_get_abstract(info=None):
    """    Obtain if the object type is an abstract type, eg if it cannot be
    instantiated
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: %TRUE if the object type is abstract
    @rtype: bool
    """
    return object

def object_info_get_class_struct(info=None):
    """    Every #GObject has two structures; an instance structure and a class
    structure.  This function returns the metadata for the class structure.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the #GIStructInfo or %NULL. Free with g_base_info_unref() when done.
    @rtype: StructInfo
    """
    return object

def object_info_get_constant(info=None, n=None):
    """    Obtain an object type constant at index @n.
    @param info: a #GIObjectInfo
    @param n: index of constant to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GIConstantInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: ConstantInfo
    """
    return object

def object_info_get_field(info=None, n=None):
    """    Obtain an object type field at index @n.
    @param info: a #GIObjectInfo
    @param n: index of field to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GIFieldInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: FieldInfo
    """
    return object

def object_info_get_fundamental(info=None):
    """    Obtain if the object type is of a fundamental type which is not
    G_TYPE_OBJECT. This is mostly for supporting GstMiniObject.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: %TRUE if the object type is a fundamental type
    @rtype: bool
    """
    return object

def object_info_get_get_value_function(info=None):
    """    Obtain the symbol name of the function that should be called to convert
    an object instance pointer of this object type to a GValue.
    I's mainly used fundamental types. The type signature for the symbol
    is %GIObjectInfoGetValueFunction, to fetch the function pointer
    see g_object_info_get_get_value_function().
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the symbol or %NULL
    @rtype: str
    """
    return object

def object_info_get_get_value_function_pointer(info=None):
    """    Obtain a pointer to a function which can be used to
    extract an instance of this object type out of a GValue.
    This takes derivation into account and will reversely traverse
    the base classes of this type, starting at the top type.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the function pointer or %NULL
    @rtype: ObjectInfoGetValueFunction
    """
    return object

def object_info_get_interface(info=None, n=None):
    """    Obtain an object type interface at index @n.
    @param info: a #GIObjectInfo
    @param n: index of interface to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GIInterfaceInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: InterfaceInfo
    """
    return object

def object_info_get_method(info=None, n=None):
    """    Obtain an object type method at index @n.
    @param info: a #GIObjectInfo
    @param n: index of method to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def object_info_get_n_constants(info=None):
    """    Obtain the number of constants that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of constants
    @rtype: int
    """
    return object

def object_info_get_n_fields(info=None):
    """    Obtain the number of fields that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of fields
    @rtype: int
    """
    return object

def object_info_get_n_interfaces(info=None):
    """    Obtain the number of interfaces that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of interfaces
    @rtype: int
    """
    return object

def object_info_get_n_methods(info=None):
    """    Obtain the number of methods that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of methods
    @rtype: int
    """
    return object

def object_info_get_n_properties(info=None):
    """    Obtain the number of properties that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of properties
    @rtype: int
    """
    return object

def object_info_get_n_signals(info=None):
    """    Obtain the number of signals that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of signals
    @rtype: int
    """
    return object

def object_info_get_n_vfuncs(info=None):
    """    Obtain the number of virtual functions that this object type has.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: number of virtual functions
    @rtype: int
    """
    return object

def object_info_get_parent(info=None):
    """    Obtain the parent of the object type.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the #GIObjectInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: ObjectInfo
    """
    return object

def object_info_get_property(info=None, n=None):
    """    Obtain an object type property at index @n.
    @param info: a #GIObjectInfo
    @param n: index of property to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GIPropertyInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: PropertyInfo
    """
    return object

def object_info_get_ref_function(info=None):
    """    Obtain the symbol name of the function that should be called to ref this
    object type. It's mainly used fundamental types. The type signature for
    the symbol is %GIObjectInfoRefFunction, to fetch the function pointer
    see g_object_info_get_ref_function().
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the symbol or %NULL
    @rtype: str
    """
    return object

def object_info_get_ref_function_pointer(info=None):
    """    Obtain a pointer to a function which can be used to
    increase the reference count an instance of this object type.
    This takes derivation into account and will reversely traverse
    the base classes of this type, starting at the top type.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the function pointer or %NULL
    @rtype: ObjectInfoRefFunction
    """
    return object

def object_info_get_set_value_function(info=None):
    """    Obtain the symbol name of the function that should be called to convert
    set a GValue giving an object instance pointer of this object type.
    I's mainly used fundamental types. The type signature for the symbol
    is %GIObjectInfoSetValueFunction, to fetch the function pointer
    see g_object_info_get_set_value_function().
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the symbol or %NULL
    @rtype: str
    """
    return object

def object_info_get_set_value_function_pointer(info=None):
    """    Obtain a pointer to a function which can be used to
    set a GValue given an instance of this object type.
    This takes derivation into account and will reversely traverse
    the base classes of this type, starting at the top type.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the function pointer or %NULL
    @rtype: ObjectInfoSetValueFunction
    """
    return object

def object_info_get_signal(info=None, n=None):
    """    Obtain an object type signal at index @n.
    @param info: a #GIObjectInfo
    @param n: index of signal to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GISignalInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: SignalInfo
    """
    return object

def object_info_get_type_init(info=None):
    """    Obtain the function which when called will return the GType
    function for which this object type is registered.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the type init function
    @rtype: str
    """
    return object

def object_info_get_type_name(info=None):
    """    Obtain the name of the objects class/type.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: name of the objects type
    @rtype: str
    """
    return object

def object_info_get_unref_function(info=None):
    """    Obtain the symbol name of the function that should be called to unref this
    object type. It's mainly used fundamental types. The type signature for
    the symbol is %GIObjectInfoUnrefFunction, to fetch the function pointer
    see g_object_info_get_unref_function().
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the symbol or %NULL
    @rtype: str
    """
    return object

def object_info_get_unref_function_pointer(info=None):
    """    Obtain a pointer to a function which can be used to
    decrease the reference count an instance of this object type.
    This takes derivation into account and will reversely traverse
    the base classes of this type, starting at the top type.
    @param info: a #GIObjectInfo
    @type info: ObjectInfo
    @returns: the function pointer or %NULL
    @rtype: ObjectInfoUnrefFunction
    """
    return object

def object_info_get_vfunc(info=None, n=None):
    """    Obtain an object type virtual function at index @n.
    @param info: a #GIObjectInfo
    @param n: index of virtual function to get
    @type info: ObjectInfo
    @type n: int
    @returns: the #GIVFuncInfo. Free the struct by calling g_base_info_unref() when done.
    @rtype: VFuncInfo
    """
    return object

def property_info_get_flags(info=None):
    """    Obtain the flags for this property info. See #GParamFlags for
    more information about possible flag values.
    @param info: a #GIPropertyInfo
    @type info: PropertyInfo
    @returns: the flags
    @rtype: GObject.ParamFlags
    """
    return object

def property_info_get_ownership_transfer(info=None):
    """    Obtain the ownership transfer for this property. See #GITransfer for more
    information about transfer values.
    @param info: a #GIPropertyInfo
    @type info: PropertyInfo
    @returns: the transfer
    @rtype: Transfer
    """
    return object

def property_info_get_type(info=None):
    """    Obtain the type information for the property @info.
    @param info: a #GIPropertyInfo
    @type info: PropertyInfo
    @returns: the #GITypeInfo, free it with g_base_info_unref() when done.
    @rtype: TypeInfo
    """
    return object

def registered_type_info_get_g_type(info=None):
    """    Obtain the #GType for this registered type or G_TYPE_NONE which a special meaning.
    It means that either there is no type information associated with this @info or
    that the shared library which provides the type_init function for this
    @info cannot be called.
    @param info: a #GIRegisteredTypeInfo
    @type info: RegisteredTypeInfo
    @returns: the #GType.
    @rtype: GType
    """
    return object

def registered_type_info_get_type_init(info=None):
    """    Obtain the type init function for @info. The type init function is the
    function which will register the GType within the GObject type system.
    Usually this is not called by langauge bindings or applications, use
    g_registered_type_info_get_g_type() directly instead.
    @param info: a #GIRegisteredTypeInfo
    @type info: RegisteredTypeInfo
    @returns: the symbol name of the type init function, suitable for passing into g_module_symbol().
    @rtype: str
    """
    return object

def registered_type_info_get_type_name(info=None):
    """    Obtain the type name of the struct within the GObject type system.
    This type can be passed to g_type_name() to get a #GType.
    @param info: a #GIRegisteredTypeInfo
    @type info: RegisteredTypeInfo
    @returns: the type name
    @rtype: str
    """
    return object

def signal_info_get_class_closure(info=None):
    """    Obtain the class closure for this signal if one is set. The class
    closure is a virtual function on the type that the signal belongs to.
    If the signal lacks a closure %NULL will be returned.
    @param info: a #GISignalInfo
    @type info: SignalInfo
    @returns: the class closure or %NULL
    @rtype: VFuncInfo
    """
    return object

def signal_info_get_flags(info=None):
    """    Obtain the flags for this signal info. See #GSignalFlags for
    more information about possible flag values.
    @param info: a #GISignalInfo
    @type info: SignalInfo
    @returns: the flags
    @rtype: GObject.SignalFlags
    """
    return object

def signal_info_true_stops_emit(info=None):
    """    Obtain if the returning true in the signal handler will
    stop the emission of the signal.
    @param info: a #GISignalInfo
    @type info: SignalInfo
    @returns: %TRUE if returning true stops the signal emission
    @rtype: bool
    """
    return object

def struct_info_find_field(info=None, name=None):
    """    Obtain the type information for field named @name.
    @param info: a #GIStructInfo
    @param name: a field name
    @type info: StructInfo
    @type name: str
    @returns: the #GIFieldInfo or %NULL if not found, free it with g_base_info_unref() when done.
    @rtype: FieldInfo
    """
    return object

def struct_info_find_method(info=None, name=None):
    """    Obtain the type information for method named @name.
    @param info: a #GIStructInfo
    @param name: a method name
    @type info: StructInfo
    @type name: str
    @returns: the #GIFunctionInfo, free it with g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def struct_info_get_alignment(info=None):
    """    Obtain the required alignment of the structure.
    @param info: a #GIStructInfo
    @type info: StructInfo
    @returns: required alignment in bytes
    @rtype: gsize
    """
    return object

def struct_info_get_field(info=None, n=None):
    """    Obtain the type information for field with specified index.
    @param info: a #GIStructInfo
    @param n: a field index
    @type info: StructInfo
    @type n: int
    @returns: the #GIFieldInfo, free it with g_base_info_unref() when done.
    @rtype: FieldInfo
    """
    return object

def struct_info_get_method(info=None, n=None):
    """    Obtain the type information for method with specified index.
    @param info: a #GIStructInfo
    @param n: a method index
    @type info: StructInfo
    @type n: int
    @returns: the #GIFunctionInfo, free it with g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def struct_info_get_n_fields(info=None):
    """    Obtain the number of fields this structure has.
    @param info: a #GIStructInfo
    @type info: StructInfo
    @returns: number of fields
    @rtype: int
    """
    return object

def struct_info_get_n_methods(info=None):
    """    Obtain the number of methods this structure has.
    @param info: a #GIStructInfo
    @type info: StructInfo
    @returns: number of methods
    @rtype: int
    """
    return object

def struct_info_get_size(info=None):
    """    Obtain the total size of the structure.
    @param info: a #GIStructInfo
    @type info: StructInfo
    @returns: size of the structure in bytes
    @rtype: gsize
    """
    return object

def struct_info_is_foreign(info=None):
    """    TODO
    @param info: TODO
    @type info: StructInfo
    @returns: TODO
    @rtype: bool
    """
    return object

def struct_info_is_gtype_struct(info=None):
    """    Return true if this structure represents the "class structure" for some
    #GObject or #GInterface.  This function is mainly useful to hide this kind of structure
    from generated public APIs.
    @param info: a #GIStructInfo
    @type info: StructInfo
    @returns: %TRUE if this is a class struct, %FALSE otherwise
    @rtype: bool
    """
    return object

def type_info_get_array_fixed_size(info=None):
    """    Obtain the fixed array size of the type. The type tag must be a
    #GI_TYPE_TAG_ARRAY or -1 will returned.
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: the size or -1 if it's not an array
    @rtype: int
    """
    return object

def type_info_get_array_length(info=None):
    """    Obtain the array length of the type. The type tag must be a
    #GI_TYPE_TAG_ARRAY or -1 will returned.
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: the array length, or -1 if the type is not an array
    @rtype: int
    """
    return object

def type_info_get_array_type(info=None):
    """    Obtain the array type for this type. See #GIArrayType for a list of
    possible values. If the type tag of this type is not array, -1 will be
    returned.
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: the array type or -1
    @rtype: ArrayType
    """
    return object

def type_info_get_interface(info=None):
    """    For types which have #GI_TYPE_TAG_INTERFACE such as GObjects and boxed values,
    this function returns full information about the referenced type.  You can then
    inspect the type of the returned #GIBaseInfo to further query whether it is
    a concrete GObject, a GInterface, a structure, etc. using g_base_info_get_type().
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: the #GIBaseInfo, or %NULL. Free it with g_base_info_unref() when done.
    @rtype: BaseInfo
    """
    return object

def type_info_get_param_type(info=None, n=None):
    """    Obtain the parameter type @n.
    @param info: a #GITypeInfo
    @param n: index of the parameter
    @type info: TypeInfo
    @type n: int
    @returns: the param type info
    @rtype: TypeInfo
    """
    return object

def type_info_get_tag(info=None):
    """    Obtain the type tag for the type. See #GITypeTag for a list
    of type tags.
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: the type tag
    @rtype: TypeTag
    """
    return object

def type_info_is_pointer(info=None):
    """    Obtain if the type is passed as a reference.
    
    Note that the types of %GI_DIRECTION_OUT and %GI_DIRECTION_INOUT parameters
    will only be pointers if the underlying type being transferred is a pointer
    (i.e. only if the type of the C function’s formal parameter is a pointer to a
    pointer).
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: %TRUE if it is a pointer
    @rtype: bool
    """
    return object

def type_info_is_zero_terminated(info=None):
    """    Obtain if the last element of the array is %NULL. The type tag must be a
    #GI_TYPE_TAG_ARRAY or %FALSE will returned.
    @param info: a #GITypeInfo
    @type info: TypeInfo
    @returns: %TRUE if zero terminated
    @rtype: bool
    """
    return object

def type_tag_to_string(type=None):
    """    Obtain a string representation of @type
    @param type: the type_tag
    @type type: TypeTag
    @returns: the string
    @rtype: str
    """
    return object

def union_info_find_method(info=None, name=None):
    """    Obtain the type information for method named @name.
    @param info: a #GIUnionInfo
    @param name: a method name
    @type info: UnionInfo
    @type name: str
    @returns: the #GIFunctionInfo, free it with g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def union_info_get_alignment(info=None):
    """    Obtain the required alignment of the union.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: required alignment in bytes
    @rtype: gsize
    """
    return object

def union_info_get_discriminator(info=None, n=None):
    """    Obtain discriminator value assigned for n-th union field, i.e. n-th
    union field is the active one if discriminator contains this
    constant.
    @param info: a #GIUnionInfo
    @param n: a union field index
    @type info: UnionInfo
    @type n: int
    @returns: the #GIConstantInfo, free it with g_base_info_unref() when done.
    @rtype: ConstantInfo
    """
    return object

def union_info_get_discriminator_offset(info=None):
    """    Returns offset of the discriminator field in the structure.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: offset in bytes of the discriminator
    @rtype: int
    """
    return object

def union_info_get_discriminator_type(info=None):
    """    Obtain the type information of the union discriminator.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: the #GITypeInfo, free it with g_base_info_unref() when done.
    @rtype: TypeInfo
    """
    return object

def union_info_get_field(info=None, n=None):
    """    Obtain the type information for field with specified index.
    @param info: a #GIUnionInfo
    @param n: a field index
    @type info: UnionInfo
    @type n: int
    @returns: the #GIFieldInfo, free it with g_base_info_unref() when done.
    @rtype: FieldInfo
    """
    return object

def union_info_get_method(info=None, n=None):
    """    Obtain the type information for method with specified index.
    @param info: a #GIUnionInfo
    @param n: a method index
    @type info: UnionInfo
    @type n: int
    @returns: the #GIFunctionInfo, free it with g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def union_info_get_n_fields(info=None):
    """    Obtain the number of fields this union has.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: number of fields
    @rtype: int
    """
    return object

def union_info_get_n_methods(info=None):
    """    Obtain the number of methods this union has.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: number of methods
    @rtype: int
    """
    return object

def union_info_get_size(info=None):
    """    Obtain the total size of the union.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: size of the union in bytes
    @rtype: gsize
    """
    return object

def union_info_is_discriminated(info=None):
    """    Return true if this union contains discriminator field.
    @param info: a #GIUnionInfo
    @type info: UnionInfo
    @returns: %TRUE if this is a discriminated union, %FALSE otherwise
    @rtype: bool
    """
    return object

def value_info_get_value(info=None):
    """    Obtain the enumeration value of the #GIValueInfo.
    @param info: a #GIValueInfo
    @type info: ValueInfo
    @returns: the enumeration value. This will always be representable
   as a 32-bit signed or unsigned value. The use of gint64 as the
   return type is to allow both.
    @rtype: int
    """
    return object

def vfunc_info_get_address(info=None, implementor_gtype=None):
    """    This method will look up where inside the type struct of @implementor_gtype
    is the implementation for @info.
    @param info: a #GIVFuncInfo
    @param implementor_gtype: #GType implementing this virtual function
    @type info: VFuncInfo
    @type implementor_gtype: GType
    @returns: address to a function or %NULL if an error happened
    @rtype: gpointer
    """
    return object

def vfunc_info_get_flags(info=None):
    """    Obtain the flags for this virtual function info. See #GIVFuncInfoFlags for
    more information about possible flag values.
    @param info: a #GIVFuncInfo
    @type info: VFuncInfo
    @returns: the flags
    @rtype: VFuncInfoFlags
    """
    return object

def vfunc_info_get_invoker(info=None):
    """    If this virtual function has an associated invoker method, this
    method will return it.  An invoker method is a C entry point.
    
    Not all virtuals will have invokers.
    @param info: a #GIVFuncInfo
    @type info: VFuncInfo
    @returns: the #GIVFuncInfo or %NULL. Free it with g_base_info_unref() when done.
    @rtype: FunctionInfo
    """
    return object

def vfunc_info_get_offset(info=None):
    """    Obtain the offset of the function pointer in the class struct. The value
    0xFFFF indicates that the struct offset is unknown.
    @param info: a #GIVFuncInfo
    @type info: VFuncInfo
    @returns: the struct offset or 0xFFFF if it's unknown
    @rtype: int
    """
    return object

def vfunc_info_get_signal(info=None):
    """    Obtain the signal for the virtual function if one is set.
    The signal comes from the object or interface to which
    this virtual function belongs.
    @param info: a #GIVFuncInfo
    @type info: VFuncInfo
    @returns: the signal or %NULL if none set
    @rtype: SignalInfo
    """
    return object

def vfunc_info_invoke(info=None, implementor=None, in_args=None, n_in_args=None, out_args=None, n_out_args=None, return_value=None):
    """    Invokes the function described in @info with the given
    arguments. Note that inout parameters must appear in both
    argument lists.
    @param info: a #GIVFuncInfo describing the virtual function to invoke
    @param implementor: #GType of the type that implements this virtual function
    @param in_args: an array of #GIArgument<!-- -->s, one for each in    parameter of @info. If there are no in parameter, @in_args    can be %NULL
    @param n_in_args: the length of the @in_args array
    @param out_args: an array of #GIArgument<!-- -->s, one for each out    parameter of @info. If there are no out parameters, @out_args    may be %NULL
    @param n_out_args: the length of the @out_args array
    @param return_value: return location for the return value of the    function. If the function returns void, @return_value may be    %NULL
    @type info: VFuncInfo
    @type implementor: GType
    @type n_in_args: int
    @type n_out_args: int
    @type return_value: Argument
    @returns: %TRUE if the function has been invoked, %FALSE if an
   error occurred.
    @rtype: bool
    """
    return object


class AttributeIter():
    """An opaque structure used to iterate over attributes
in a #GIBaseInfo struct."""

    @property
    def data(self):
        return object

    @property
    def data2(self):
        return object

    @property
    def data3(self):
        return object

    @property
    def data4(self):
        return object


class BaseInfo():
    """GIBaseInfo is the common base struct of all other *Info structs
accessible through the #GIRepository API.
All other structs can be casted to a #GIBaseInfo, for instance:
<example>
<title>Casting a #GIFunctionInfo to #GIBaseInfo</title>
<programlisting>
   GIFunctionInfo *function_info = ...;
   GIBaseInfo *info = (GIBaseInfo*)function_info;
</programlisting>
</example>
Most #GIRepository APIs returning a #GIBaseInfo is actually creating a new struct, in other
words, g_base_info_unref() has to be called when done accessing the data.
GIBaseInfos are normally accessed by calling either
g_irepository_find_by_name(), g_irepository_find_by_gtype() or g_irepository_get_info().

<example>
<title>Getting the Button of the Gtk typelib</title>
<programlisting>
   GIBaseInfo *button_info = g_irepository_find_by_name(NULL, "Gtk", "Button");
   ... use button_info ...
   g_base_info_unref(button_info);
</programlisting>
</example>

<refsect1 id="gi-gibaseinfo.struct-hierarchy" role="struct_hierarchy">
<title role="struct_hierarchy.title">Struct hierarchy</title>
<synopsis>
  GIBaseInfo
   +----<link linkend="gi-GIArgInfo">GIArgInfo</link>
   +----<link linkend="gi-GICallableInfo">GICallableInfo</link>
   +----<link linkend="gi-GIConstantInfo">GIConstantInfo</link>
   +----<link linkend="gi-GIFieldInfo">GIFieldInfo</link>
   +----<link linkend="gi-GIPropertyInfo">GIPropertyInfo</link>
   +----<link linkend="gi-GIRegisteredTypeInfo">GIRegisteredTypeInfo</link>
   +----<link linkend="gi-GITypeInfo">GITypeInfo</link>
</synopsis>
</refsect1>"""
    
    def equal(self, info2=None):
        """        Compare two #GIBaseInfo.
        
        Using pointer comparison is not practical since many functions return
        different instances of #GIBaseInfo that refers to the same part of the
        TypeLib; use this function instead to do #GIBaseInfo comparisons.
        @param info2: a #GIBaseInfo
        @type info2: BaseInfo
        @returns: %TRUE if and only if @info1 equals @info2.
        @rtype: bool
        """
        return object
    
    def get_attribute(self, name=None):
        """        Retrieve an arbitrary attribute associated with this node.
        @param name: a freeform string naming an attribute
        @type name: str
        @returns: The value of the attribute, or %NULL if no such attribute exists
        @rtype: str
        """
        return object
    
    def get_container(self):
        """        Obtain the container of the @info. The container is the parent
        GIBaseInfo. For instance, the parent of a #GIFunctionInfo is an
        #GIObjectInfo or #GIInterfaceInfo.
        @returns: the container
        @rtype: BaseInfo
        """
        return object
    
    def get_name(self):
        """        Obtain the name of the @info. What the name represents depends on
        the #GIInfoType of the @info. For instance for #GIFunctionInfo it is
        the name of the function.
        @returns: the name of @info or %NULL if it lacks a name.
        @rtype: str
        """
        return object
    
    def get_namespace(self):
        """        Obtain the namespace of @info.
        @returns: the namespace
        @rtype: str
        """
        return object
    
    def get_type(self):
        """        Obtain the info type of the GIBaseInfo.
        @returns: the info type of @info
        @rtype: InfoType
        """
        return object
    
    def get_typelib(self):
        """        Obtain the typelib this @info belongs to
        @returns: the typelib.
        @rtype: Typelib
        """
        return object
    
    def is_deprecated(self):
        """        Obtain whether the @info is represents a metadata which is
        deprecated or not.
        @returns: %TRUE if deprecated
        @rtype: bool
        """
        return object
    
    def iterate_attributes(self, iterator=None, name=None, value=None):
        """        Iterate over all attributes associated with this node.  The iterator
        structure is typically stack allocated, and must have its first
        member initialized to %NULL.  Attributes are arbitrary namespaced key–value
        pairs which can be attached to almost any item.  They are intended for use
        by software higher in the toolchain than bindings, and are distinct from
        normal GIR annotations.
        
        Both the @name and @value should be treated as constants
        and must not be freed.
        
        <example>
        <title>Iterating over attributes</title>
        <programlisting>
        void
        print_attributes (GIBaseInfo *info)
        {
          GIAttributeIter iter = { 0, };
          char *name;
          char *value;
          while (g_base_info_iterate_attributes (info, &iter, &name, &value))
            {
              g_print ("attribute name: %s value: %s", name, value);
            }
        }
        </programlisting>
        </example>
        @param iterator: a #GIAttributeIter structure, must be initialized; see below
        @param name: Returned name, must not be freed
        @param value: Returned name, must not be freed
        @type iterator: AttributeIter
        @type name: str
        @type value: str
        @returns: %TRUE if there are more attributes
        @rtype: bool
        """
        return object
    
    def ref(self):
        """        Increases the reference count of @info.
        @returns: the same @info.
        @rtype: BaseInfo
        """
        return object
    
    def unref(self):
        """        Decreases the reference count of @info. When its reference count
        drops to 0, the info is freed.
        @returns: 
        @rtype: None
        """
        return object

    @property
    def dummy1(self):
        return object

    @property
    def dummy2(self):
        return object

    @property
    def dummy3(self):
        return object

    @property
    def dummy4(self):
        return object

    @property
    def dummy5(self):
        return object

    @property
    def dummy6(self):
        return object

    @property
    def dummy7(self):
        return object

    @property
    def padding(self):
        return object


class Repository(GObject.Object):
    """#GIRepository is used to manage repositories of namespaces. Namespaces
are represented on disk by type libraries (.typelib files).

### Discovery of type libraries

#GIRepository will typically look for a `girepository-1.0` directory
under the library directory used when compiling gobject-introspection.

It is possible to control the search paths programmatically, using
g_irepository_prepend_search_path(). It is also possible to modify
the search paths by using the `GI_TYPELIB_PATH` environment variable.
The environment variable takes precedence over the default search path
and the g_irepository_prepend_search_path() calls."""
    @staticmethod
    def dump(arg=None):
        """        
        @type arg: str
        @returns: 
        @rtype: bool
        """
        return object
    @staticmethod
    def error_quark():
        """        
        @returns: 
        @rtype: GLib.Quark
        """
        return object
    @staticmethod
    def get_default():
        """        Returns the singleton process-global default #GIRepository. It is
        not currently supported to have multiple repositories in a
        particular process, but this function is provided in the unlikely
        eventuality that it would become possible, and as a convenience for
        higher level language bindings to conform to the GObject method
        call conventions.
        
        All methods on #GIRepository also accept %NULL as an instance
        parameter to mean this default repository, which is usually more
        convenient for C.
        @returns: The global singleton #GIRepository
        @rtype: Repository
        """
        return object
    @staticmethod
    def get_option_group():
        """        Obtain the option group for girepository, it's used
        by the dumper and for programs that wants to provide
        introspection information
        @returns: the option group
        @rtype: GLib.OptionGroup
        """
        return object
    @staticmethod
    def get_search_path():
        """        Returns the current search path #GIRepository will use when loading
        typelib files. The list is internal to #GIRespository and should not
        be freed, nor should its string elements.
        @returns: #GSList of strings
        @rtype: GLib.SList
        """
        return object
    @staticmethod
    def prepend_library_path(directory=None):
        """        
        @type directory: str
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def prepend_search_path(directory=None):
        """        Prepends @directory to the typelib search path.
        
        See also: g_irepository_get_search_path().
        @param directory: directory name to prepend to the typelib   search path
        @type directory: filename
        @returns: 
        @rtype: None
        """
        return object
    
    def enumerate_versions(self, namespace_=None):
        """        Obtain an unordered list of versions (either currently loaded or
        available) for @namespace_ in this @repository.
        @param namespace_: GI namespace, e.g. "Gtk"
        @type namespace_: str
        @returns: the array of versions.
        @rtype: GLib.List
        """
        return object
    
    def find_by_error_domain(self, domain=None):
        """        Searches for the enum type corresponding to the given #GError
        domain. Before calling this function for a particular namespace,
        you must call g_irepository_require() once to load the namespace, or
        otherwise ensure the namespace has already been loaded.
        @param domain: a #GError domain
        @type domain: GLib.Quark
        @returns: #GIEnumInfo representing metadata about @domain's enum type, or %NULL
        @rtype: EnumInfo
        """
        return object
    
    def find_by_gtype(self, gtype=None):
        """        Searches all loaded namespaces for a particular #GType.  Note that
        in order to locate the metadata, the namespace corresponding to
        the type must first have been loaded.  There is currently no
        mechanism for determining the namespace which corresponds to an
        arbitrary GType - thus, this function will operate most reliably
        when you know the GType to originate from be from a loaded namespace.
        @param gtype: GType to search for
        @type gtype: GType
        @returns: #GIBaseInfo representing metadata about @type, or %NULL
        @rtype: BaseInfo
        """
        return object
    
    def find_by_name(self, namespace_=None, name=None):
        """        Searches for a particular entry in a namespace.  Before calling
        this function for a particular namespace, you must call
        g_irepository_require() once to load the namespace, or otherwise
        ensure the namespace has already been loaded.
        @param namespace_: Namespace which will be searched
        @param name: Entry name to find
        @type namespace_: str
        @type name: str
        @returns: #GIBaseInfo representing metadata about @name, or %NULL
        @rtype: BaseInfo
        """
        return object
    
    def get_c_prefix(self, namespace_=None):
        """        This function returns the "C prefix", or the C level namespace
        associated with the given introspection namespace.  Each C symbol
        starts with this prefix, as well each #GType in the library.
        
        Note: The namespace must have already been loaded using a function
        such as g_irepository_require() before calling this function.
        @param namespace_: Namespace to inspect
        @type namespace_: str
        @returns: C namespace prefix, or %NULL if none associated
        @rtype: str
        """
        return object
    
    def get_dependencies(self, namespace_=None):
        """        Return an array of all (transitive) versioned dependencies for
        @namespace_. Returned strings are of the form
        <code>namespace-version</code>.
        
        Note: @namespace_ must have already been loaded using a function
        such as g_irepository_require() before calling this function.
        
        To get only the immediate dependencies for @namespace_, use
        g_irepository_get_immediate_dependencies().
        @param namespace_: Namespace of interest
        @type namespace_: str
        @rtype: None
        """
        return object
    
    def get_immediate_dependencies(self, namespace_=None):
        """        Return an array of the immediate versioned dependencies for @namespace_.
        Returned strings are of the form <code>namespace-version</code>.
        
        Note: @namespace_ must have already been loaded using a function
        such as g_irepository_require() before calling this function.
        
        To get the transitive closure of dependencies for @namespace_, use
        g_irepository_get_dependencies().
        @param namespace_: Namespace of interest
        @type namespace_: str
        @rtype: None
        """
        return object
    
    def get_info(self, namespace_=None, index=None):
        """        This function returns a particular metadata entry in the
        given namespace @namespace_.  The namespace must have
        already been loaded before calling this function.
        See g_irepository_get_n_infos() to find the maximum number of
        entries.
        @param namespace_: Namespace to inspect
        @param index: 0-based offset into namespace metadata for entry
        @type namespace_: str
        @type index: int
        @returns: #GIBaseInfo containing metadata
        @rtype: BaseInfo
        """
        return object
    
    def get_loaded_namespaces(self):
        """        Return the list of currently loaded namespaces.
        @rtype: None
        """
        return object
    
    def get_n_infos(self, namespace_=None):
        """        This function returns the number of metadata entries in
        given namespace @namespace_.  The namespace must have
        already been loaded before calling this function.
        @param namespace_: Namespace to inspect
        @type namespace_: str
        @returns: number of metadata entries
        @rtype: int
        """
        return object
    
    def get_shared_library(self, namespace_=None):
        """        This function returns a comma-separated list of paths to the
        shared C libraries associated with the given namespace @namespace_.
        There may be no shared library path associated, in which case this
        function will return %NULL.
        
        Note: The namespace must have already been loaded using a function
        such as g_irepository_require() before calling this function.
        @param namespace_: Namespace to inspect
        @type namespace_: str
        @returns: Comma-separated list of paths to shared libraries,
   or %NULL if none are associated
        @rtype: str
        """
        return object
    
    def get_typelib_path(self, namespace_=None):
        """        If namespace @namespace_ is loaded, return the full path to the
        .typelib file it was loaded from.  If the typelib for
        namespace @namespace_ was included in a shared library, return
        the special string "&lt;builtin&gt;".
        @param namespace_: GI namespace to use, e.g. "Gtk"
        @type namespace_: str
        @returns: Filesystem path (or $lt;builtin$gt;) if successful, %NULL if namespace is not loaded
        @rtype: str
        """
        return object
    
    def get_version(self, namespace_=None):
        """        This function returns the loaded version associated with the given
        namespace @namespace_.
        
        Note: The namespace must have already been loaded using a function
        such as g_irepository_require() before calling this function.
        @param namespace_: Namespace to inspect
        @type namespace_: str
        @returns: Loaded version
        @rtype: str
        """
        return object
    
    def is_registered(self, namespace_=None, version=None):
        """        Check whether a particular namespace (and optionally, a specific
        version thereof) is currently loaded.  This function is likely to
        only be useful in unusual circumstances; in order to act upon
        metadata in the namespace, you should call g_irepository_require()
        instead which will ensure the namespace is loaded, and return as
        quickly as this function will if it has already been loaded.
        @param namespace_: Namespace of interest
        @param version: Required version, may be %NULL for latest
        @type namespace_: str
        @type version: str
        @returns: %TRUE if namespace-version is loaded, %FALSE otherwise
        @rtype: bool
        """
        return object
    
    def load_typelib(self, typelib=None, flags=None):
        """        TODO
        @param typelib: TODO
        @param flags: TODO
        @type typelib: Typelib
        @type flags: RepositoryLoadFlags
        @returns: 
        @rtype: str
        """
        return object
    
    def require(self, namespace_=None, version=None, flags=None):
        """        Force the namespace @namespace_ to be loaded if it isn't already.
        If @namespace_ is not loaded, this function will search for a
        ".typelib" file using the repository search path.  In addition, a
        version @version of namespace may be specified.  If @version is
        not specified, the latest will be used.
        @param namespace_: GI namespace to use, e.g. "Gtk"
        @param version: Version of namespace, may be %NULL for latest
        @param flags: Set of %GIRepositoryLoadFlags, may be 0
        @type namespace_: str
        @type version: str
        @type flags: RepositoryLoadFlags
        @returns: a pointer to the #GITypelib if successful, %NULL otherwise
        @rtype: Typelib
        """
        return object
    
    def require_private(self, typelib_dir=None, namespace_=None, version=None, flags=None):
        """        Force the namespace @namespace_ to be loaded if it isn't already.
        If @namespace_ is not loaded, this function will search for a
        ".typelib" file within the private directory only. In addition, a
        version @version of namespace should be specified.  If @version is
        not specified, the latest will be used.
        @param typelib_dir: Private directory where to find the requested typelib
        @param namespace_: GI namespace to use, e.g. "Gtk"
        @param version: Version of namespace, may be %NULL for latest
        @param flags: Set of %GIRepositoryLoadFlags, may be 0
        @type typelib_dir: str
        @type namespace_: str
        @type version: str
        @type flags: RepositoryLoadFlags
        @returns: a pointer to the #GITypelib if successful, %NULL otherwise
        @rtype: Typelib
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def priv(self):
        return object


class RepositoryClass():
    """"""

    @property
    def parent(self):
        return object


class RepositoryPrivate():
    """"""


class Typelib():
    """TODO"""
    
    def free(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def get_namespace(self):
        """        
        @returns: 
        @rtype: str
        """
        return object
    
    def symbol(self, symbol_name=None, symbol=None):
        """        
        @type symbol_name: str
        @type symbol: gpointer
        @returns: 
        @rtype: bool
        """
        return object
    @staticmethod
    def new_from_const_memory(memory=None, len=None):
        """        
        @type memory: guint8
        @type len: gsize
        @returns: 
        @rtype: Typelib
        """
        return object
    @staticmethod
    def new_from_mapped_file(mfile=None):
        """        
        @type mfile: GLib.MappedFile
        @returns: 
        @rtype: Typelib
        """
        return object
    @staticmethod
    def new_from_memory(memory=None, len=None):
        """        
        @type memory: guint8
        @type len: gsize
        @returns: 
        @rtype: Typelib
        """
        return object


class UnresolvedInfo():
    """Represents a unresolved type in a typelib."""
